package entity.thread;

import entity.thread.waitNotify.Cook;
import entity.thread.waitNotify.Foodie;

import java.util.concurrent.*;

public class DemoClass {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        /*实现线程方法一继承Thread
         * 1、创建一个线程类MyThread继承Thread
         * 2、重写MyThread中的run方法
         * 3、在实现类里new一个MyThread对象
         * 4、用实例对象执行start方法
         * */
//        MyThread t1=new MyThread("子线程1");
//        MyThread t2=new MyThread("子线程2");
//        t1.start();
//        t2.start();

        /*实现线程方法二实现runnable接口
         * 1、创建一个线程任务实现Runnable
         * 2、重写run方法
         * 3、创建一个线程任务对象
         * 4、将线程任务对象包装成线程对象
         * 5、执行start方法
         * */
//        Runnable target=new MyRunnable();
//        Thread t3=new Thread(target,"Runnable1号线程");
//        Thread t4=new Thread(target,"Runnable2号线程");
//        t3.start();
//        t4.start();

        /*实现线程方法三实现Callable接口
         * 1、创建一个线程任务实现Callable，并设置其返回结果
         * 2、重写call方法
         * 3、创建一个线程任务对象
         * 4、将线程任务对象包装成未来任务对象FutureTask
         * 5、将未来任务对象包装成线程对象
         * 5、执行start方法
         * */
//        //MyCallable线程任务对象
//        MyCallable mc=new MyCallable(100);
//        //未来任务对象FutureTask
//        FutureTask<String> ft=new FutureTask<>(mc);
//        Thread t=new Thread(ft);
//        t.start();
//        String result= ft.get();
//        System.out.println("结果->"+result);


        //setPriority设置优先级 （默认5，最小1，最大10），优先级越高，抢到cpu的概率越高，但不会百分百抢到执行权，只是概率问题
        //getPriority获取优先级
//        MyRunnable mr=new MyRunnable();
//        Thread th1=new Thread(mr,"测试1");
//        th1.setPriority(10);
//        System.out.println(th1.getName()+"优先级-》"+th1.getPriority());


        //守护线程当时非守护线程执行结束后，守护线程也就没有存在的必要了
//        MyThread t1=new MyThread("女神");
//        MyThread t2=new MyThread("备胎");
//        //守护线程设置参数
////        t2.setDaemon(false);
//        t1.start();
//        t2.start();
//        //插入线程，争夺cpu执行权
//        t2.join();
//        //主线程
//        for (int i = 0; i < 10; i++) {
//            System.out.println(Thread.currentThread().getName()+"->"+i);
//        }


        //a、创建一个线程池，指定线程的固定数量是3
//        ExecutorService pools= Executors.newFixedThreadPool(3);
////        Runnable target=new MyRunnable();
////        pools.submit(target);//提交任务，此时会创建一个新线程，自动启动线程执行
////        pools.submit(target);//提交任务，此时会创建一个新线程，自动启动线程执行
////        pools.submit(target);//提交任务，此时会创建一个新线程，自动启动线程执行
////        pools.submit(target);//不会再创建新线程，会复用之前的线程处理这个任务
//
//
//        Future<String> f1=pools.submit(new MyCallable(100));
//        Future<String> f2=pools.submit(new MyCallable(200));
//        Future<String> f3=pools.submit(new MyCallable(300));
//
//        System.out.println(f1.get());
//        System.out.println(f2.get());
//        System.out.println(f3.get());

//
//        pools.shutdown();//等待任务执行完毕关闭线程池
//        pools.shutdownNow();//立即关闭


        //测试消费者生产者
//        Cook c=new Cook();
//        Foodie f=new Foodie();
//        c.setName("厨师");
//        f.setName("吃货");
//        c.start();
//        f.start();

        /*
         * 参数一：核心线程数量
         * 参数二：最大线程数
         * 参数三：空闲线程最大存活时间
         * 参数四：时间单位
         * 参数五：任务队列
         * 参数六：创建线程工厂
         * 参数七：任务的拒绝策略
         * */
//        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
//                3, 6, 60, TimeUnit.SECONDS,
//                new ArrayBlockingQueue<>(3),
//                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy()
//        );


    }
}
